home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 436_01 / stringts.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-07  |  8.0 KB  |  265 lines
  1. /*************************************************************************
  2.     Source File:  STRINGTS.C
  3.  
  4.     Test driver for routines in STRINGS.OBJ.
  5.  
  6.     Editors:        Microsoft Works, Microsoft Word
  7.     Compiler:    Borland Turbo C 2.01
  8.  
  9.     Copyright (c) 1993, Richard Zigler.
  10. *************************************************************************/
  11.  
  12. #include <conio.h>                        /* for clrscr(), etc.                     */
  13. #include <stdlib.h>                        /* for ato?()                                 */
  14. #include <stdio.h>                        /* for printf(), scanf(), etc.         */
  15. #include "stringz.h"                        /* string function prototypes            */
  16.  
  17. /****
  18.     The routines in STRINGS.OBJ can handle strings up to 32767 bytes
  19.     long, but the strings in the driver routine are limited to 128
  20.     characters.  To increase the size limit, redefine MAXBUF.
  21. ****/
  22.  
  23. /**** Data Type Synonyms ****/
  24.  
  25. typedef unsigned char    BYTE;
  26. typedef unsigned short    WORD;
  27. typedef unsigned long    DWORD;
  28. typedef int                    FLAG;                /* int-size true/false flag        */
  29. typedef char                BFLAG;            /* byte-size true/false flag        */
  30.  
  31. #define OPS                     12
  32. #define MAXBUF                128
  33.  
  34. static char *StringOps[OPS] =                /* menu options                        */
  35. {
  36.     " 0 -- Quit"                ,
  37.     " 1 -- Left    String"    ,
  38.     " 2 -- Mid     String"    ,
  39.     " 3 -- Right   String"    ,
  40.     " 4 -- Left    Trim"        ,
  41.     " 5 -- Right   Trim"        ,
  42.     " 6 -- Left    Justify"    ,
  43.     " 7 -- Right   Justify"    ,
  44.     " 8 -- Center  String"    ,
  45.     " 9 -- Replace String"    ,
  46.     "10 -- Insert  String"    ,
  47.     "11 -- Create  Template",
  48. };
  49.  
  50. static char IndexStr[] =
  51. "        |         1         2         3         4         5         6|\r\n"
  52. "        |123456789012345678901234567890123456789012345678901234567890|"    ;
  53.  
  54. static char SrcStr [MAXBUF+1]    = "This is the original source string";
  55. static char SamStr [MAXBUF+1]    = "";        /* test same dest/src strings        */
  56. static char TemStr [MAXBUF+1]    = "";        /* template string                    */
  57. static char TgtStr [MAXBUF+1]    = "";        /* normal destination string        */
  58. static char NullStr[MAXBUF+1]    = "";        /* test null source string            */
  59. static char OpStr  [MAXBUF+1]         ;        /* for atoi()                            */
  60.  
  61. static char ReplaceStr[]        = "REPLACED";
  62. static char InsertStr[]         = "INSERTED";
  63. static char LineStr[]            = "----------------------";
  64. static char JstStr[]                = "  A string with two spaces at each end  ";
  65.  
  66. static char far * sPtr        ,                /* pointer to return string        */
  67.                 far * nPtr        ,                /* test null source string            */
  68.                 far *    NullPtrN    ,                /* test null dest pointers            */
  69.                 far *    NullPtrF    ;                /*  (both near and far)                */
  70.  
  71. /************************************************************************/
  72. void main(void)
  73.     {
  74.     register int    i;                            /* general and operation indexes    */
  75.     int                op;
  76.     short                ch,                        /* parameter variables                */
  77.                         start,
  78.                         num,
  79.                         yn;
  80.     char            *    srcptr;                    /* ptr to source string                */
  81.     char            *    strcpy( char *, char * );
  82.  
  83. #if defined(__TURBOC__)
  84.     extern char        _video;                    /* internal Turbo C table            */
  85.     *((char *)&_video + 10) = 0;            /* turn off snow control            */
  86. #endif
  87.  
  88.     do
  89.         {
  90.         clrscr();
  91.         for ( i = 0 ; i < OPS ; i++ )
  92.             cprintf( "%s\r\n", StringOps[i] );
  93.         cprintf( "%s\r\n", LineStr );
  94.         do
  95.             {
  96.             cprintf( "Choose operation:  " );
  97.             op = atoi( gets( OpStr ) );
  98.             gotoxy( 1, wherey() - 1 );
  99.             delline();
  100.             }
  101.         while( op < 0 || op >= OPS || !*OpStr );
  102.         if ( op ==  0 )
  103.             break;                                /* out of main loop                    */
  104.         *NullStr = *TgtStr = '\0';
  105.         NullPtrN = (char near *) 0;
  106.         NullPtrF = (char far  *) 0;
  107.         srcptr = (op == 4 || op == 5) ? JstStr : SrcStr ;
  108.         strcpy( SamStr, srcptr );
  109.         clrscr();
  110.         cprintf
  111.             (
  112.             "%s\r\n"
  113.             "%s\r\n"
  114.             "\r\n"
  115.             "%s\r\n"
  116.             "Source: |%s|\r\n"
  117.             "\r\n"
  118.             , StringOps[op], LineStr, IndexStr, srcptr
  119.             );
  120.         switch ( op )
  121.             {
  122.             case 2 :                                /* get start and fall through        */
  123.                 cprintf( " Start: " );
  124.                 start = atoi( gets( OpStr ) );
  125.             case 1 :
  126.             case 3 :
  127.                 cprintf( "Length: " );
  128.                 if ( (num = atoi( gets( OpStr ) )) > MAXBUF )
  129.                     num = MAXBUF;
  130.                 switch ( op )
  131.                     {
  132.                     case 1 :
  133.                         sPtr        = LeftStr( SamStr,    SamStr,    num );
  134.                         sPtr        = LeftStr( TgtStr,    srcptr,    num );
  135.                         nPtr        = LeftStr( NullStr,    "",        num );
  136.                         NullPtrF    = LeftStr( NullPtrF,    srcptr,    num );
  137.                         NullPtrN = LeftStr( NullPtrN, srcptr,    num );
  138.                         break;
  139.                     case 2 :
  140.                         sPtr        = MidStr( SamStr,        SamStr,    start, num );
  141.                         sPtr        = MidStr( TgtStr,        srcptr,    start, num );
  142.                         nPtr        = MidStr( NullStr,    "",        start, num );
  143.                         NullPtrF    = MidStr( NullPtrF,    srcptr,    start, num );
  144.                         NullPtrN = MidStr( NullPtrN,    srcptr,    start, num );
  145.                         break;
  146.                     case 3 :
  147.                         sPtr        = RightStr( SamStr,        SamStr,    num );
  148.                         sPtr        = RightStr( TgtStr,        srcptr,    num );
  149.                         nPtr        = RightStr( NullStr,        "",        num );
  150.                         NullPtrF    = RightStr( NullPtrF,    srcptr,    num );
  151.                         NullPtrN = RightStr( NullPtrN,    srcptr,    num );
  152.                         break;
  153.                     }
  154.                 break;
  155.             case 4 :
  156.                 sPtr        = lTrim( SamStr,        SamStr    );
  157.                 sPtr        = lTrim( TgtStr,        srcptr    );
  158.                 nPtr        = lTrim( NullStr,        ""            );
  159.                 NullPtrF    = lTrim( NullPtrF,    srcptr    );
  160.                 NullPtrN = lTrim( NullPtrN,    srcptr    );
  161.                 break;
  162.             case 5 :
  163.                 sPtr        = rTrim( SamStr,        SamStr    );
  164.                 sPtr        = rTrim( TgtStr,        srcptr    );
  165.                 nPtr        = rTrim( NullStr,        ""            );
  166.                 NullPtrF    = rTrim( NullPtrF,    srcptr    );
  167.                 NullPtrN = rTrim( NullPtrN,    srcptr    );
  168.                 break;
  169.             case 6 :
  170.             case 7 :
  171.             case 8 :
  172.                 cprintf( "  Size: " );
  173.                 num = atoi( gets( OpStr ) );
  174.                 if ( num > MAXBUF )
  175.                     num = MAXBUF;
  176.                 cprintf( "  Fill: " );
  177.                 ch = getche(); putchar( '\n' );
  178.                 switch ( op )
  179.                     {
  180.                     case 6 :
  181.                         sPtr        = lJust( SamStr,        SamStr,    num, ch );
  182.                         sPtr        = lJust( TgtStr,        srcptr,    num, ch );
  183.                         nPtr        = lJust( NullStr,        "",        num, ch );
  184.                         NullPtrF    = lJust( NullPtrF,    srcptr,    num, ch );
  185.                         NullPtrN = lJust( NullPtrN,    srcptr,    num, ch );
  186.                         break;
  187.                     case 7 :
  188.                         sPtr        = rJust( SamStr,        SamStr,    num, ch );
  189.                         sPtr        = rJust( TgtStr,        srcptr,    num, ch );
  190.                         nPtr        = rJust( NullStr,        "",        num, ch );
  191.                         NullPtrF    = rJust( NullPtrF,    srcptr,    num, ch );
  192.                         NullPtrN = rJust( NullPtrN,    srcptr,    num, ch );
  193.                         break;
  194.                     case 8 :
  195.                         sPtr        = cJust( SamStr,        SamStr,    num, ch );
  196.                         sPtr        = cJust( TgtStr,        srcptr,    num, ch );
  197.                         nPtr        = cJust( NullStr,        "",        num, ch );
  198.                         NullPtrF    = cJust( NullPtrF,    srcptr,    num, ch );
  199.                         NullPtrN = cJust( NullPtrN,    srcptr,    num, ch );
  200.                         break;
  201.                     }                                /* switch                                */
  202.                 break;
  203.             case  9:
  204.             case 10:
  205.                 strcpy( TgtStr, srcptr );
  206.                 cprintf( "Start: " );
  207.                 start = atoi( gets( OpStr ) );
  208.                 if ( op == 9 )
  209.                     {
  210.                     sPtr        = ReplStr( SamStr,    SamStr,        start );
  211.                     sPtr        = ReplStr( TgtStr,    ReplaceStr,    start );
  212.                     nPtr        = ReplStr( NullStr,    ReplaceStr,    start );
  213.                     NullPtrF    = ReplStr( NullPtrF,    ReplaceStr,    start );
  214.                     NullPtrN = ReplStr( NullPtrN,    ReplaceStr,    start );
  215.                     }
  216.                 else
  217.                     {
  218.                     sPtr        = InsStr( SamStr,        SamStr,        start );
  219.                     sPtr        = InsStr( TgtStr,        InsertStr,    start );
  220.                     nPtr        = InsStr( NullStr,    InsertStr,    start );
  221.                     NullPtrF    = InsStr( NullPtrF,    InsertStr,    start );
  222.                     NullPtrN = InsStr( NullPtrN,    InsertStr,    start );
  223.                     }
  224.                 break;
  225.             case 11:
  226.                 cprintf( "Enter template: " );
  227.                 gets( TgtStr );
  228.                 cprintf( "  Enter source: " );
  229.                 gets( TemStr );
  230.                 cprintf( "    Enter flag: " );
  231.                 ch = getche(); putchar( '\n' );
  232.                 strcpy( SamStr, TgtStr );
  233.                 sPtr        = TemplStr( SamStr,        SamStr, ch );
  234.                 sPtr        = TemplStr( TgtStr,        TemStr, ch );
  235.                 nPtr        = TemplStr( NullStr,        TemStr, ch );
  236.                 NullPtrF    = TemplStr( NullPtrF,    TemStr, ch );
  237.                 NullPtrN = TemplStr( NullPtrN,    TemStr, ch );
  238.                 break;
  239.             }                                        /* switch                                */
  240.         cprintf
  241.             (
  242.             "\r\n"
  243.             "Destination Strings\r\n"
  244.             "%s\r\n"
  245.             "\r\n"
  246.             "%s\r\n"
  247.             "  Same: |%s|\r\n"
  248.             "Target: |%s|\r\n"
  249.             " Blank: |%s|\r\n"
  250.             " NullF: %Fp\r\n"
  251.             " NullN: %Fp\r\n"
  252.             "\r\n"
  253.             "Quit (y/n)? "
  254.             , LineStr, IndexStr, SamStr
  255.             , (char *) sPtr, (char *) nPtr, NullPtrF, NullPtrN
  256.             );
  257.  
  258.         if ( (yn = getche()) == 0 )
  259.             yn = getche();
  260.         }
  261.     while ( yn != 'y' && yn != 'Y' );
  262.     }
  263.  
  264. /**** EOF:  STRINGTS.C ****/
  265.